'\" t
.\"     Title: PREPARE
.\"    Author: The PostgreSQL Global Development Group
.\" Generator: DocBook XSL Stylesheets v1.75.2 <http://docbook.sf.net/>
.\"      Date: 2011-12-01
.\"    Manual: PostgreSQL 9.1.2 Documentation
.\"    Source: PostgreSQL 9.1.2
.\"  Language: English
.\"
.TH "PREPARE" "7" "2011-12-01" "PostgreSQL 9.1.2" "PostgreSQL 9.1.2 Documentation"
.\" -----------------------------------------------------------------
.\" * Define some portability stuff
.\" -----------------------------------------------------------------
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.\" http://bugs.debian.org/507673
.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html
.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.ie \n(.g .ds Aq \(aq
.el       .ds Aq '
.\" -----------------------------------------------------------------
.\" * set default formatting
.\" -----------------------------------------------------------------
.\" disable hyphenation
.nh
.\" disable justification (adjust text to left margin only)
.ad l
.\" -----------------------------------------------------------------
.\" * MAIN CONTENT STARTS HERE *
.\" -----------------------------------------------------------------
.SH "NAME"
PREPARE \- prepare a statement for execution
.\" PREPARE
.\" prepared statements: creating
.SH "SYNOPSIS"
.sp
.nf
PREPARE \fIname\fR [ ( \fIdata_type\fR [, \&.\&.\&.] ) ] AS \fIstatement\fR
.fi
.SH "DESCRIPTION"
.PP

PREPARE
creates a prepared statement\&. A prepared statement is a server\-side object that can be used to optimize performance\&. When the
PREPARE
statement is executed, the specified statement is parsed, rewritten, and planned\&. When an
EXECUTE
command is subsequently issued, the prepared statement need only be executed\&. Thus, the parsing, rewriting, and planning stages are only performed once, instead of every time the statement is executed\&.
.PP
Prepared statements can take parameters: values that are substituted into the statement when it is executed\&. When creating the prepared statement, refer to parameters by position, using
$1,
$2, etc\&. A corresponding list of parameter data types can optionally be specified\&. When a parameter\*(Aqs data type is not specified or is declared as
unknown, the type is inferred from the context in which the parameter is used (if possible)\&. When executing the statement, specify the actual values for these parameters in the
EXECUTE
statement\&. Refer to
\fBEXECUTE\fR(7)
for more information about that\&.
.PP
Prepared statements only last for the duration of the current database session\&. When the session ends, the prepared statement is forgotten, so it must be recreated before being used again\&. This also means that a single prepared statement cannot be used by multiple simultaneous database clients; however, each client can create their own prepared statement to use\&. The prepared statement can be manually cleaned up using the
\fBDEALLOCATE\fR(7)
command\&.
.PP
Prepared statements have the largest performance advantage when a single session is being used to execute a large number of similar statements\&. The performance difference will be particularly significant if the statements are complex to plan or rewrite, for example, if the query involves a join of many tables or requires the application of several rules\&. If the statement is relatively simple to plan and rewrite but relatively expensive to execute, the performance advantage of prepared statements will be less noticeable\&.
.SH "PARAMETERS"
.PP
\fIname\fR
.RS 4
An arbitrary name given to this particular prepared statement\&. It must be unique within a single session and is subsequently used to execute or deallocate a previously prepared statement\&.
.RE
.PP
\fIdata_type\fR
.RS 4
The data type of a parameter to the prepared statement\&. If the data type of a particular parameter is unspecified or is specified as
unknown, it will be inferred from the context in which the parameter is used\&. To refer to the parameters in the prepared statement itself, use
$1,
$2, etc\&.
.RE
.PP
\fIstatement\fR
.RS 4
Any
SELECT,
INSERT,
UPDATE,
DELETE, or
VALUES
statement\&.
.RE
.SH "NOTES"
.PP
In some situations, the query plan produced for a prepared statement will be inferior to the query plan that would have been chosen if the statement had been submitted and executed normally\&. This is because when the statement is planned and the planner attempts to determine the optimal query plan, the actual values of any parameters specified in the statement are unavailable\&.
PostgreSQL
collects statistics on the distribution of data in the table, and can use constant values in a statement to make guesses about the likely result of executing the statement\&. Since this data is unavailable when planning prepared statements with parameters, the chosen plan might be suboptimal\&. To examine the query plan
PostgreSQL
has chosen for a prepared statement, use
\fBEXPLAIN\fR(7)\&.
.PP
For more information on query planning and the statistics collected by
PostgreSQL
for that purpose, see the
\fBANALYZE\fR(7)
documentation\&.
.PP
You can see all available prepared statements of a session by querying the
pg_prepared_statements
system view\&.
.SH "EXAMPLES"
.PP
Create a prepared statement for an
INSERT
statement, and then execute it:
.sp
.if n \{\
.RS 4
.\}
.nf
PREPARE fooplan (int, text, bool, numeric) AS
    INSERT INTO foo VALUES($1, $2, $3, $4);
EXECUTE fooplan(1, \*(AqHunter Valley\*(Aq, \*(Aqt\*(Aq, 200\&.00);
.fi
.if n \{\
.RE
.\}
.PP
Create a prepared statement for a
SELECT
statement, and then execute it:
.sp
.if n \{\
.RS 4
.\}
.nf
PREPARE usrrptplan (int) AS
    SELECT * FROM users u, logs l WHERE u\&.usrid=$1 AND u\&.usrid=l\&.usrid
    AND l\&.date = $2;
EXECUTE usrrptplan(1, current_date);
.fi
.if n \{\
.RE
.\}
.sp
Note that the data type of the second parameter is not specified, so it is inferred from the context in which
$2
is used\&.
.SH "COMPATIBILITY"
.PP
The SQL standard includes a
PREPARE
statement, but it is only for use in embedded SQL\&. This version of the
PREPARE
statement also uses a somewhat different syntax\&.
.SH "SEE ALSO"
\fBDEALLOCATE\fR(7), \fBEXECUTE\fR(7)
